package com.atde._05_behavioral_design_patterns.interpreter;


import java.util.HashMap;
import java.util.Stack;

/**
 * @BelongsProject: hsp_java_design_mode
 * @BelongsPackage: com.atde._05_behavioral_design_patterns.interpreter
 * @Author: Del
 * @CreateTime: 2025-06-30  09:44
 * @Description: 解释器模式：
 * @Version: 1.0
 */
public class Calculator {
    // 定义表达式
    private Expression expression;

    public Calculator(String expStr) {
        // 安排运算选后顺序
        Stack<Expression> stack = new Stack<>();
        // 表达式拆分成字符数组
        char[] charArray = expStr.toCharArray();

        Expression left = null;
        Expression right = null;
        // 遍历字符数组，创建左右 operand，并创建 symbolExpression
        for (int i = 0; i < charArray.length; i++) {
            switch (charArray[i]) {
                case '+':
                    // 从栈中弹出左 operand
                    left = stack.pop();
                    // 取出右 operand
                    right = new VarExpression(String.valueOf(charArray[++i]));
                    // 创建 symbolExpression，并压入栈中
                    // 根据得到 left 和 right 构建 AddExpression 加入到 stack 中
                    stack.push(new AddExpression(left, right));
                    break;
                case '-':
                    left = stack.pop();
                    right = new VarExpression(String.valueOf(charArray[++i]));
                    stack.push(new SubExpression(left, right));
                    break;
                default:
                    // 如果是一个 Var就创建要给VarExpression 对象，并压入栈中
                    stack.push(new VarExpression(String.valueOf(charArray[i])));
                    break;
            }
        }
        // 创建解释器的核心，就是把所有的表达式放到栈中，然后进行运算
        // 当遍历完整个 charArray 数组之后，stack 就得到最后 Expression 对象
        this.expression = stack.pop();
    }
    public int run(HashMap<String, Integer> var) {
        // 将表达式 a + b 和 var绑定
        // 然后传递给 Expression 的 interpreter 进行解释执行
        return this.expression.interpret(var);
    }
}
